就<!-- 退料检验单添加修改表单组件 -->
<template>
  <div class="rqc-form">
    <!-- 导航标签 -->
    <el-tabs v-model="activeTab" type="card" class="form-tabs">
      <el-tab-pane label="基本信息" name="basicInfo"></el-tab-pane>
      <el-tab-pane label="来源信息" name="sourceInfo"></el-tab-pane>
      <el-tab-pane label="物料信息" name="materialInfo" v-if="type === 'edit' || type === 'view'"></el-tab-pane>
      <el-tab-pane label="检测信息" name="testData" v-if="type === 'edit' || type === 'view'"></el-tab-pane>
      <el-tab-pane label="检测项目" name="testItems" v-if="type === 'edit' || type === 'view'"></el-tab-pane>
    </el-tabs>

    <!-- 表单内容区域 -->
    <div class="form-content-area">
      <!-- 基本信息卡片 -->
      <el-card class="form-card" shadow="hover" v-show="activeTab === 'basicInfo'">
        <div slot="header" class="card-header">
          <span>基本信息</span>
        </div>
        <el-form ref="form" :model="rqcForm" :rules="rules" label-width="120px" class="form-container">
          <el-row :gutter="30">
            <el-col :span="10">
              <el-form-item label="检验单编号" prop="rqcCode" class="form-item" required>
                <div class="input-with-btn">
                  <el-input
                    v-model="rqcForm.rqcCode"
                    placeholder="请输入检验单编号"
                    :disabled="isView || type === 'edit'"
                    :class="{'disabled-input': isView || type === 'edit'}"
                    @input="handleInputChange('rqcCode')">
                    <el-button
                      v-if="type === 'add'"
                      slot="append"
                      type="primary"
                      icon="el-icon-refresh"
                      class="inner-button"
                      @click="handleGenerateCode"
                      :loading="codeLoading">
                      生成
                    </el-button>
                  </el-input>
                </div>
              </el-form-item>
            </el-col>
            <el-col :span="10">
              <el-form-item label="检验单名称" prop="rqcName" class="form-item" required>
                <el-input
                  v-model="rqcForm.rqcName"
                  placeholder="请输入检验单名称"
                  :disabled="isView"
                  @input="handleInputChange('rqcName')" />
              </el-form-item>
            </el-col>
          </el-row>

          <el-row :gutter="30">
            <el-col :span="10">
              <el-form-item label="检验模板" prop="templateId" class="form-item" required v-if="type === 'edit' || type === 'view'">
                <div class="input-with-btn">
                  <el-input
                    :value="getTemplateDisplay()"
                    placeholder="请输入检验模板"
                    :disabled="isView"
                    @input="handleInputChange('templateId')">
                    <el-button
                      v-if="!isView"
                      slot="append"
                      type="primary"
                      icon="el-icon-search"
                      class="inner-button"
                      @click="openTemplatePlanSelector">
                      选择
                    </el-button>
                  </el-input>
                </div>
              </el-form-item>
            </el-col>
            <el-col :span="10">
              <el-form-item label="检验类型" prop="rqcType" class="form-item" required>
                <el-select
                  v-model="rqcForm.rqcType"
                  placeholder="请选择检验类型"
                  :disabled="isView"
                  style="width: 100%"
                  @change="handleInputChange('rqcType')">
                  <el-option
                    v-for="dict in rqcTypeOptions"
                    :key="dict.value"
                    :label="dict.label"
                    :value="dict.value"
                  ></el-option>
                </el-select>
              </el-form-item>
            </el-col>
          </el-row>

          
        </el-form>
      </el-card>

      <!-- 来源信息卡片 -->
      <el-card class="form-card" shadow="hover" v-show="activeTab === 'sourceInfo'">
        <div slot="header" class="card-header">
          <span>来源信息</span>
        </div>
        <el-form :model="rqcForm" label-width="120px" class="form-container">
          <el-row :gutter="30">
            <el-col :span="10">
              <el-form-item label="来源单据类型" prop="sourceDocType" class="form-item" required>
                <el-select
                  v-model="rqcForm.sourceDocType"
                  placeholder="请选择来源单据类型"
                  :disabled="isView"
                  style="width: 100%"
                  @change="handleInputChange('sourceDocType')">
                  <el-option
                    v-for="dict in sourceDocTypeOptions"
                    :key="dict.value"
                    :label="dict.label"
                    :value="dict.value"
                  ></el-option>
                </el-select>
              </el-form-item>
            </el-col>
            <el-col :span="10">
              <el-form-item label="来源单据编号" prop="sourceDocCode" class="form-item" required>
                <div class="input-with-btn">
                  <el-input
                    v-model="rqcForm.sourceDocCode"
                    placeholder="请输入来源单据编号"
                    :disabled="isView"
                    @input="handleInputChange('sourceDocCode')">
                    <el-button
                      v-if="!isView"
                      slot="append"
                      type="primary"
                      icon="el-icon-search"
                      class="inner-button"
                      @click="openReturnIssueSelector">
                      选择
                    </el-button>
                  </el-input>
                </div>
              </el-form-item>
            </el-col>
          </el-row>

          <el-row :gutter="30">
            <el-col :span="10">
              <el-form-item label="来源单据ID" prop="sourceDocId" class="form-item" required>
                <el-input
                  v-model="rqcForm.sourceDocId"
                  placeholder="请输入来源单据ID"
                  :disabled="isView"
                  @input="handleInputChange('sourceDocId')" />
              </el-form-item>
            </el-col>

          </el-row>
        </el-form>
      </el-card>

      <!-- 物料信息卡片 -->
      <el-card class="form-card" shadow="hover" v-show="activeTab === 'materialInfo' && (type === 'edit' || type === 'view')">
        <div slot="header" class="card-header">
          <span>物料信息</span>
        </div>
        <el-form :model="rqcForm" label-width="120px" class="form-container">
          <el-row :gutter="30">
            
            <el-col :span="10">
              <el-form-item label="物料编码" prop="materialCode" class="form-item" required>
                <el-input
                  v-model="rqcForm.materialCode"
                  placeholder="请输入物料编码"
                  :disabled="isView"
                  @blur="handleMaterialCodeBlur" />
              </el-form-item>
            </el-col>
          </el-row>

          <el-row :gutter="30">
            <el-col :span="10">
              <el-form-item label="物料名称" prop="materialName" class="form-item" required>
                <el-input
                  v-model="rqcForm.materialName"
                  placeholder="请输入物料名称"
                  :disabled="isView" />
              </el-form-item>
            </el-col>
            <el-col :span="10">
              <el-form-item label="规格型号" prop="materialSfn" class="form-item" required>
                <el-input
                  v-model="rqcForm.materialSfn"
                  placeholder="请输入规格型号"
                  :disabled="isView" />
              </el-form-item>
            </el-col>
          </el-row>

          <el-row :gutter="30">
            <el-col :span="10">
              <el-form-item label="单位" prop="unit" class="form-item" required>
                <el-input
                  v-model="rqcForm.unit"
                  placeholder="请输入单位"
                  :disabled="isView"
                  @input="handleInputChange('unit')" />
              </el-form-item>
            </el-col>

          </el-row>
        </el-form>
      </el-card>

      <!-- 检测信息卡片 -->
      <el-card class="form-card" shadow="hover" v-show="activeTab === 'testData' && (type === 'edit' || type === 'view')">
        <div slot="header" class="card-header">
          <span>检测信息</span>
        </div>
        <el-form :model="rqcForm" label-width="120px" class="form-container">
          <el-row :gutter="30">
            <el-col :span="10">
              <el-form-item label="检测数量" prop="quantityCheckNum" class="form-item" required>
                <el-input-number
                  v-model="rqcForm.quantityCheckNum"
                  placeholder="请输入检测数量"
                  :disabled="true"
                  :min="0"
                  :precision="0"
                  style="width: 100%"
                  @change="handleInputChange('quantityCheckNum')" />
                <div class="form-tip" v-if="templateParams.quantityCheckNum > 0">
                  <i class="el-icon-info"></i> 检验模板规定最低检测数量：{{ templateParams.quantityCheckNum }}
                </div>
                <div class="form-tip" v-if="rqcForm.sourceDocId">
                  <i class="el-icon-warning" style="color:#E6A23C;"></i> 本次检测数量不能超过本次接收数量
                </div>
              </el-form-item>
            </el-col>
            <el-col :span="10">
              <el-form-item label="不合格数" prop="quantityUnqualifiedNum" class="form-item" required>
                <el-input-number
                  v-model="rqcForm.quantityUnqualifiedNum"
                  placeholder="请输入不合格数"
                  :disabled="isView"
                  :min="0"
                  :precision="0"
                  style="width: 100%" />
                <div class="form-tip" v-if="templateParams.quantityUnqualifiedNum > 0">
                  <i class="el-icon-warning" style="color:#E6A23C;"></i> 检验模板规定最大不合格数限制：{{ templateParams.quantityUnqualifiedNum }}，超出将自动设置检测结果为不合格
                </div>
              </el-form-item>
            </el-col>
          </el-row>

          <el-row :gutter="30">
            <el-col :span="10">
              <el-form-item label="合格品数量" prop="quantityQualifiedNum" class="form-item" required>
                <el-input-number
                  v-model="rqcForm.quantityQualifiedNum"
                  placeholder="请输入合格品数量"
                  :disabled="isView"
                  :min="0"
                  :precision="0"
                  style="width: 100%" />
              </el-form-item>
            </el-col>
            <el-col :span="10">
              <el-form-item label="检测结果" prop="checkResult" class="form-item" required>
                <el-select
                  v-model="rqcForm.checkResult"
                  placeholder="请选择检测结果"
                  :disabled="isView"
                  style="width: 100%">
                  <el-option
                    v-for="dict in checkResultOptions"
                    :key="dict.value"
                    :label="dict.label"
                    :value="dict.value"
                  ></el-option>
                </el-select>
                <div class="form-tip">
                  <i class="el-icon-info"></i> 系统将根据质检方案参数进行自动判断提示
                </div>
              </el-form-item>
            </el-col>
          </el-row>

          <el-row :gutter="30">
            <el-col :span="10">
              <el-form-item label="检测日期" prop="inspectDate" class="form-item" required>
                <el-date-picker
                  v-model="rqcForm.inspectDate"
                  type="date"
                  placeholder="请选择检测日期"
                  value-format="yyyy-MM-dd"
                  :disabled="isView"
                  style="width: 100%"
                  :picker-options="pickerOptions"
                ></el-date-picker>
              </el-form-item>
            </el-col>
            
            <el-col :span="10">
              <!-- 使用隐藏字段保存userId，但不显示输入框 -->
              <input type="hidden" v-model="rqcForm.userId" />
              
              <el-form-item label="检测人员" prop="userName" class="form-item" required>
                <div class="input-with-btn">
                  <el-input
                    v-model="rqcForm.userName"
                    placeholder="请选择检测人员"
                    readonly
                    :disabled="isView"
                    :class="{'disabled-input': isView}"
                    @click="!isView && openUserDialog()"
                    style="width: 80%; display: inline-block;"
                  />
                  <el-button
                    type="primary"
                    icon="el-icon-search"
                    @click="openUserDialog"
                    style="margin-left: 8px;"
                    :disabled="isView"
                  >选择</el-button>
                </div>
              </el-form-item>
            </el-col>
          </el-row>

          <!-- 删除重复的检测人员名称表单项 -->
          <!-- <el-row :gutter="30">
            <el-col :span="10">
              <el-form-item label="检测人员名称" prop="userName" class="form-item">
                <el-input
                  v-model="rqcForm.userName"
                  placeholder="请选择检测人员"
                  readonly
                  @focus="openUserDialog"
                  style="width: 80%; display: inline-block;"
                />

              </el-form-item>
            </el-col>
          </el-row> -->
        </el-form>
      </el-card>

      <!-- 检测项卡片 -->
      <el-card class="form-card" shadow="hover" v-show="activeTab === 'testItems' && (type === 'edit' || type === 'view')">
        <div slot="header" class="card-header">
          <span>检测项目列表</span>
        </div>
        <rqc-test-items-list
          ref="testItemsList"
          :rqcId="rqcForm.rqcId"
          :templateId="rqcForm.templateId"
        />
      </el-card>
    </div>

    <!-- 底部按钮区域 -->
    <div class="form-footer">
      <el-button type="primary" @click="submitForm" :loading="submitting" v-if="!isView">确 定</el-button>
      <el-button @click="cancel" :disabled="submitting">{{ isView ? '返 回' : '取 消' }}</el-button>
    </div>

    <!-- 检验模板选择器 -->
    <template-plan-selector
      :visible.sync="templateSelectorVisible"
      @select="handleTemplateSelect"
      @close="templateSelectorVisible = false"
    />

    <!-- 员工选择弹窗 -->
    <select-user-dialog
      :visible.sync="userDialogVisible"
      title="选择检测人员"
      :multi="false"
      node-key="id"
      @confirm="handleUserConfirm"
    />

    <!-- 退料单选择弹窗 -->
    <el-dialog
      title="选择来源单据"
      :visible.sync="returnIssueDialogVisible"
      width="900px"
      append-to-body
    >
      <!-- 搜索表单 -->
      <el-form :inline="true" :model="returnIssueQueryParams" size="small">
        <el-form-item label="单据编号">
          <el-input
            v-model="returnIssueQueryParams.recpt_code"
            placeholder="请输入单据编号"
            clearable
            @keyup.enter.native="handleReturnIssueSearch"
          />
        </el-form-item>
        <el-form-item label="单据名称">
          <el-input
            v-model="returnIssueQueryParams.recpt_name"
            placeholder="请输入单据名称"
            clearable
            @keyup.enter.native="handleReturnIssueSearch"
          />
        </el-form-item>
        <el-form-item>
          <el-button type="primary" icon="el-icon-search" size="mini" @click="handleReturnIssueSearch">搜索</el-button>
          <el-button icon="el-icon-refresh" size="mini" @click="resetReturnIssueSearch">重置</el-button>
        </el-form-item>
      </el-form>

      <el-table
        v-loading="returnIssueLoading"
        :data="returnIssueList"
        @row-click="handleReturnIssueRowClick"
        highlight-current-row
        style="width: 100%"
        :header-cell-style="{background:'#eef1f6',color:'#606266'}"
      >
        <el-table-column label="单据编号" prop="recpt_code" width="150" />
        <el-table-column label="单据名称" prop="recpt_name" />

        <el-table-column label="退料日期" prop="recpt_date" width="120">
          <template slot-scope="scope">
            {{ scope.row.recpt_date ? scope.row.recpt_date.substring(0, 10) : '' }}
          </template>
        </el-table-column>
        <el-table-column label="批次号" prop="batch_code" />
      </el-table>

      <!-- 分页组件 -->
      <pagination
        v-show="returnIssueTotal > 0"
        :total="returnIssueTotal"
        :page.sync="returnIssuePageNum"
        :limit.sync="returnIssuePageSize"
        @pagination="loadReturnIssueList"
        style="margin-top: 15px;"
      />

      <div slot="footer" class="dialog-footer">
        <el-button @click="returnIssueDialogVisible = false">取 消</el-button>
        <el-button type="primary" @click="confirmReturnIssue">确 定</el-button>
      </div>
    </el-dialog>
  </div>
</template>

<script>
import { getAutoNumbers, getAutoNumbersConsume } from "@/api/basic/numbers.js"
import TemplatePlanSelector from "./TemplatePlanSelector.vue"
import RqcTestItemsList from "./RqcTestItemsList.vue"
import SelectUserDialog from '@/views/qc/components/SelectUserDialog.vue'
import { selectCkRtIssueQC, updateCkRtIssueStatus } from '@/api/qc/ReturnInspection.js'
import { selectCkProductRecptDetectSingle } from '@/api/qc/IncomingInspection.js'
import { selectQcTemplateProductMaterialCode } from "@/api/qc/QualitySchemeOrder";
import Pagination from "@/components/Pagination"

// 引入HTTP客户端
import http from '@/utils/request';


export default {
  name: "RqcForm",
  components: {
    TemplatePlanSelector,
    RqcTestItemsList,
    SelectUserDialog,
    Pagination
  },
  props: {
    formData: {
      type: Object,
      default: () => ({})
    },
    type: {
      type: String,
      default: 'add' // add, edit, view
    }
  },
      data() {
    return {
      activeTab: 'basicInfo', // 当前激活的标签页
      codeLoading: false, // 自动生成编码的加载状态
      submitting: false, // 表单提交加载状态
      isSystemCode: true, // 是否使用系统编号
      templateSelectorVisible: false, // 检验模板选择器显示状态
      userDialogVisible: false, // 员工选择弹窗显示状态
      returnIssueDialogVisible: false, // 退料单选择弹窗显示状态
      returnIssueLoading: false, // 退料单加载状态
      returnIssueList: [], // 退料单列表
      selectedReturnIssue: null, // 当前选中的退料单
      isInitializing: true, // 是否为初始化阶段，用于控制提示显示
      pickerOptions: {
        disabledDate(time) {
          return time.getTime() < new Date().setHours(0, 0, 0, 0);
        }
      },
      // 退料单查询参数
      returnIssueQueryParams: {
        recpt_code: '',
        recpt_name: '',
        status: 2
      },
      returnIssueTotal: 0, // 退料单总数
      returnIssuePageNum: 1, // 当前页码
      returnIssuePageSize: 10, // 每页条数
      // 检测方案参数（不显示，仅用于验证）
      templateParams: {
        quantityCheckNum: 0,      // 最低检测数
        quantityUnqualifiedNum: 0, // 最大不合格数
        crRate: 0,                // 最大致命缺陷率
        majRate: 0,               // 最大严重缺陷率
        minRate: 0                // 最大轻微缺陷率
      },
      // 表单参数
      rqcForm: {
        rqcId: null,
        rqcCode: null,
        rqcName: null,
        templateId: null,
        templateCode: null, // 新增字段，存储检验模板编码
        templateName: null, // 新增字段，存储检验模板名称
        sourceDocId: null,
        sourceDocType: '1', // 默认为退料单
        sourceDocCode: null,
        sourceLineId: null,
        rqcType: '4', // 默认为退料检验
        materialId: null,
        materialCode: null,
        materialName: null,
        materialSfn: null,
        unit: null,
        unitName: null,
        batchId: null,
        batchCode: null,
        quantityCheckNum: 0,
        quantityUnqualifiedNum: 0,
        quantityQualifiedNum: 0,
        checkResult: '3', // 默认为待检
        inspectDate: null,
        userId: null,
        userName: null,
        nickName: null,
        status: '1' // 默认为草稿
      },
      // 默认表单值，用于重置
      defaultForm: {
        rqcId: null,
        rqcCode: null,
        rqcName: null,
        templateId: null,
        templateCode: null,
        templateName: null,
        sourceDocId: null,
        sourceDocType: '1', // 默认为退料单
        sourceDocCode: null,
        sourceLineId: null,
        rqcType: '4', // 默认为退料检验
        materialId: null,
        materialCode: null,
        materialName: null,
        materialSfn: null,
        unit: null,
        unitName: null,
        batchId: null,
        batchCode: null,
        quantityCheckNum: 0,
        quantityUnqualifiedNum: 0,
        quantityQualifiedNum: 0,
        crQuantityNum: 0,   // 致命缺陷数量
        majQuantityNum: 0,  // 严重缺陷数量
        minQuantityNum: 0,  // 轻微缺陷数量
        checkResult: '3',   // 默认为待检
        inspectDate: null,
        userId: null,
        userName: null,
        nickName: null,
        status: '1' // 默认为草稿
      },
      // 表单校验
      rules: {
        rqcCode: [
          { required: true, message: "检验单编号不能为空", trigger: "blur" }
        ],
        rqcName: [
          { required: true, message: "检验单名称不能为空", trigger: "blur" }
        ],
        templateId: [
          { required: true, message: "检验模板ID不能为空", trigger: "blur" }
        ],
        rqcType: [
          { required: true, message: "检验类型不能为空", trigger: "change" }
        ],
        status: [
          { required: true, message: "单据状态不能为空", trigger: "change" }
        ],
        sourceDocId: [
          { required: true, message: "来源单据ID不能为空", trigger: "blur" }
        ],
        sourceDocType: [
          { required: true, message: "来源单据类型不能为空", trigger: "change" }
        ],
        sourceDocCode: [
          { required: true, message: "来源单据编号不能为空", trigger: "blur" }
        ],
        materialId: [
          { required: true, message: "物料ID不能为空", trigger: "blur" }
        ],
        materialCode: [
          { required: true, message: "物料编码不能为空", trigger: "blur" }
        ],
        materialName: [
          { required: true, message: "物料名称不能为空", trigger: "blur" }
        ],
        materialSfn: [
          { required: true, message: "规格型号不能为空", trigger: "blur" }
        ],
        unit: [
          { required: true, message: "单位不能为空", trigger: "blur" }
        ],
        quantityCheckNum: [
          { required: true, message: "检测数量不能为空", trigger: "blur" }
        ],
        quantityUnqualifiedNum: [
          { required: true, message: "不合格数不能为空", trigger: "blur" }
        ],
        quantityQualifiedNum: [
          { required: true, message: "合格品数量不能为空", trigger: "blur" }
        ],
        checkResult: [
          { required: true, message: "检测结果不能为空", trigger: "change" }
        ],
        inspectDate: [
          { required: true, message: "检测日期不能为空", trigger: "change" }
        ],
        userId: [
          { required: true, message: "检测人员ID不能为空", trigger: "blur" }
        ],
        userName: [
          { required: true, message: "检测人员名称不能为空", trigger: "blur" }
        ]
      },
      // 检验类型选项
      rqcTypeOptions: [
        { value: "1", label: "来料检验" },
        { value: "2", label: "出货检验" },
        { value: "3", label: "过程检验" },
        { value: "4", label: "退料检验" }
      ],
      // 来源单据类型选项
      sourceDocTypeOptions: [
        { value: "1", label: "退料单" }
      ],
      // 检测结果选项
      checkResultOptions: [
        { value: "1", label: "合格" },
        { value: "2", label: "不合格" },
        { value: "3", label: "待检" }
      ],
      // 单据状态选项
      statusOptions: [
        { value: "1", label: "草稿" },
        { value: "2", label: "已提交" },
        { value: "3", label: "已审核" }
      ]
    };
  },
  computed: {
    isView() {
      return this.type === 'view';
    }
  },
  watch: {
    formData: {
      handler(val) {
        this.activeTab = 'basicInfo';
        console.log('RqcForm接收到formData变化:', val);

        if (val && Object.keys(val).length > 0) {
          // 使用深拷贝确保不会修改原始对象
          const formData = JSON.parse(JSON.stringify({ ...this.defaultForm, ...val }));

          // 处理日期格式 (可选)
          if (formData.inspectDate && typeof formData.inspectDate === 'string') {
            if (formData.inspectDate.includes(' ')) {
              formData.inspectDate = formData.inspectDate.split(' ')[0];
              console.log('初始化时格式化inspectDate:', formData.inspectDate);
            }
          }

          // 确保检测人员字段正确显示
          if (!formData.userName && formData.nickName) {
            formData.userName = formData.nickName;
          }
          
          // 处理可能存在的数据类型问题
          if (formData.userId !== null && formData.userId !== undefined) {
            // 确保userId有值并正确显示
            formData.userId = String(formData.userId);
            console.log('处理后的userId:', formData.userId, '类型:', typeof formData.userId);
          } else {
            console.warn('警告: 表单数据中缺少userId字段');
          }
          
          // 标记为初始化阶段，避免显示不必要的提示
          this.isInitializing = true;
          
          // 保存原始模板ID，用于后续比较
          const originalTemplateId = formData.templateId;
          
          // 调试输出完整表单数据
          console.log('完整表单数据:', JSON.stringify(formData));

          // 先清空当前表单，再赋值，避免残留旧数据
          this.rqcForm = JSON.parse(JSON.stringify(this.defaultForm));

          // 使用nextTick确保DOM更新完成后再进行赋值
          this.$nextTick(() => {
            console.log('准备更新表单数据:', formData);
            this.rqcForm = formData;
            
            console.log('更新后的检测人员信息:', {
              userId: this.rqcForm.userId,
              userName: this.rqcForm.userName,
              nickName: this.rqcForm.nickName
            });
            
            // 编辑模式下，如果有物料编码，自动查询对应的质检方案
            if ((this.type === 'edit') && this.rqcForm.materialCode) {
              this.findTemplateByMaterialCode(this.rqcForm.materialCode, true);
              this.$message.info('正在根据物料信息查询质检方案...');
            }

            // 如果是编辑或查看模式，且存在检验单ID，刷新检测项列表
            if ((this.type === 'edit' || this.type === 'view') && this.rqcForm.rqcId) {
              this.$nextTick(() => {
                if (this.$refs.testItemsList) {
                  this.$refs.testItemsList.refresh();
                }
              });
            }
            
            // 如果有检测方案ID，获取检测方案参数（静默模式）
            if (this.rqcForm.templateId) {
              this.getTemplateParams(this.rqcForm.templateId, true);
            }
            
            // 初始化完成，重置标志
            this.$nextTick(() => {
              this.isInitializing = false;
            });
          });
        } else {
          // 如果没有传入数据，重置为默认值
          console.log('无有效数据，重置表单');
          this.resetForm();
          // 重置完成后，关闭初始化标志
          this.isInitializing = false;
        }
      },
      immediate: true,
      deep: true
    },
    
    // 监听检测数量变化
    'rqcForm.quantityCheckNum': function(val) {
      if (val !== undefined) {
        this.handleInputChange('quantityCheckNum');
        
        // 检查是否满足最小检测数量
        if (this.templateParams.quantityCheckNum > 0 && val < this.templateParams.quantityCheckNum) {
          this.$message.warning(`检测数量(${val})不能低于最小检测数量(${this.templateParams.quantityCheckNum})`);
        }
        
        // 更新合格数量和不合格数量
        const checkNum = Number(val) || 0;
        const unqualifiedNum = Number(this.rqcForm.quantityUnqualifiedNum) || 0;
        
        // 如果不合格数大于检测数量，自动调整
        if (unqualifiedNum > checkNum) {
          this.rqcForm.quantityUnqualifiedNum = checkNum;
          this.rqcForm.quantityQualifiedNum = 0;
        } else {
          // 保持不合格数不变，更新合格数
          this.rqcForm.quantityQualifiedNum = Math.max(0, checkNum - unqualifiedNum);
        }
        
        this.watchQuantities();
      }
    },
    
    // 监听不合格数变化
    'rqcForm.quantityUnqualifiedNum': function(val) {
      if (val !== undefined) {
        this.handleInputChange('quantityUnqualifiedNum');
        
        // 获取当前检测数量
        const checkNum = Number(this.rqcForm.quantityCheckNum) || 0;
        const unqualifiedNum = Number(val) || 0;
        
        // 确保不合格数不大于检测数量
        if (unqualifiedNum > checkNum) {
          this.$message.warning(`不合格数(${unqualifiedNum})不能大于检测数量(${checkNum})`);
          this.rqcForm.quantityUnqualifiedNum = checkNum;
          this.rqcForm.quantityQualifiedNum = 0;
        } else {
          // 自动计算合格数量 - 核心逻辑：基于检测数量计算合格数
          this.rqcForm.quantityQualifiedNum = Math.max(0, checkNum - unqualifiedNum);
        }
        
        // 检查是否超出限制值，并自动设置检测结果为不合格
        if (this.templateParams.quantityUnqualifiedNum > 0 && unqualifiedNum > this.templateParams.quantityUnqualifiedNum) {
          this.$message.warning(`不合格数(${unqualifiedNum})已超过检验模板规定的最大不合格数(${this.templateParams.quantityUnqualifiedNum})，将自动设置检测结果为不合格`);
          // 自动标记为不合格
          this.rqcForm.checkResult = '2';
        }
        
        this.watchQuantities();
      }
    },
    
    // 监听合格数变化 - 合格数根据检测数量变化
    'rqcForm.quantityQualifiedNum': function(val) {
      if (val !== undefined) {
        this.handleInputChange('quantityQualifiedNum');
        
        const checkNum = Number(this.rqcForm.quantityCheckNum) || 0;
        const qualifiedNum = Number(val) || 0;
        
        // 确保合格数不大于检测数量
        if (qualifiedNum > checkNum) {
          this.$message.warning(`合格数(${qualifiedNum})不能大于检测数量(${checkNum})`);
          this.rqcForm.quantityQualifiedNum = checkNum;
          // 更新不合格数
          this.rqcForm.quantityUnqualifiedNum = 0;
        } else {
          // 自动计算不合格数 - 基于检测数量和合格数
          this.rqcForm.quantityUnqualifiedNum = Math.max(0, checkNum - qualifiedNum);
          
          // 检查自动计算的不合格数是否超出限制
          const newUnqualifiedNum = this.rqcForm.quantityUnqualifiedNum;
          if (this.templateParams.quantityUnqualifiedNum > 0 && 
              newUnqualifiedNum > this.templateParams.quantityUnqualifiedNum) {
            this.$message.warning(`计算得出的不合格数(${newUnqualifiedNum})超过最大不合格数(${this.templateParams.quantityUnqualifiedNum})，将自动设置检测结果为不合格`);
            this.rqcForm.checkResult = '2'; // 设置为不合格
          }
        }
        
        this.watchQuantities();
      }
    },
    
    // 监听缺陷数量变化
    'rqcForm.crQuantityNum': function() { this.watchQuantities(); },
    'rqcForm.majQuantityNum': function() { this.watchQuantities(); },
    'rqcForm.minQuantityNum': function() { this.watchQuantities(); },
    // 监听对话框关闭，确保每次打开时都是新的数据
    '$parent.open': {
      handler(val) {
        if (!val) {
          // 对话框关闭时重置表单
          this.resetForm();
        }
      },
      immediate: false
    }
  },
  created() {
    // 组件创建时初始化表单
    this.resetForm();
    
  },
  methods: {
    // 重置表单为默认值
    resetForm() {
      this.rqcForm = JSON.parse(JSON.stringify(this.defaultForm));
      this.activeTab = 'basicInfo';

      // 如果表单引用存在，重置验证
      if (this.$refs.form) {
        this.$refs.form.clearValidate();
      }
    },

    // 打开检验模板选择器
    openTemplatePlanSelector() {
      if (this.isView) return;
      
      // 检查是否已有检测方案ID
      if (this.rqcForm.templateId) {
        this.$confirm('已有检测方案，是否重新选择?', '提示', {
          confirmButtonText: '确定',
          cancelButtonText: '取消',
          type: 'warning'
        }).then(() => {
          this.templateSelectorVisible = true;
        }).catch(() => {
          // 用户取消，不执行任何操作
        });
      } else {
        this.templateSelectorVisible = true;
      }
    },

    // 打开员工选择弹窗
    openUserDialog() {
      if (this.isView) return;
      this.userDialogVisible = true;
    },

    // 处理检验模板选择
    handleTemplateSelect(plan) {
      console.log('选择的检验模板:', plan);
      if (plan) {
        // 记录原来的模板ID
        const originalTemplateId = this.rqcForm.templateId;
        
        this.rqcForm.templateId = plan.templateId;
        this.rqcForm.templateCode = plan.templateCode;
        this.rqcForm.templateName = plan.templateName;
        
        // 更新输入框显示
        this.$forceUpdate();

        // 清除templateId字段的验证提示
        if (this.$refs.form) {
          this.$refs.form.clearValidate(['templateId']);
        }

        // 用户主动选择，不使用静默模式，但如果ID没变，也不需要提示
        if (originalTemplateId !== plan.templateId) {
        this.$message.success('检验模板选择成功');
          // 获取模板参数
          this.getTemplateParams(plan.templateId, false);
        } else {
          // ID相同，静默处理
          this.getTemplateParams(plan.templateId, true);
        }
      }
    },

    // 处理员工选择
    handleUserConfirm(selection) {
      if (selection && selection.length > 0) {
        const selectedUser = selection[0];
        this.rqcForm.userId = selectedUser.userId;
        
        // 优先使用nickName，如果没有则使用userName
        this.rqcForm.userName = selectedUser.nickName || selectedUser.userName;
        
        // 保存nickName以便需要时使用
        this.rqcForm.nickName = selectedUser.nickName;
        
        console.log('选择的检测人员:', selectedUser);
        console.log('设置后的检测人员信息:', {
          userId: this.rqcForm.userId,
          userName: this.rqcForm.userName,
          nickName: this.rqcForm.nickName
        });
        
        // 清除验证信息
        if (this.$refs.form) {
          this.$refs.form.clearValidate(['userId']);
          this.$refs.form.clearValidate(['userName']);
        }
      }
      this.userDialogVisible = false;
    },

    // 自动生成编码
    handleGenerateCode() {
      if (!this.isSystemCode) {
        this.rqcForm.rqcCode = '';
        return;
      }
      this.codeLoading = true;
      getAutoNumbers(11).then(response => {
        if (response.code === 200) {
          this.rqcForm.rqcCode = response.msg;
          if (this.$refs.form) {
            this.$refs.form.clearValidate(['rqcCode']);
          }
          this.$message.success('编码生成成功');
        } else {
          this.$message.error('编码生成失败');
        }
      }).catch(() => {
        this.$message.error("生成编码异常");
      }).finally(() => {
        this.codeLoading = false;
      });
    },
    
    // 处理系统编号开关变化
    handleSystemCodeChange(val) {
      if (val) {
        // 如果开启系统编号，则生成编号
        this.handleGenerateCode();
      } else {
        // 如果关闭系统编号，则清空编号
        this.rqcForm.rqcCode = '';
      }
    },

    // 监听输入变化，清除对应字段的验证提示
    handleInputChange(field) {
      if (this.$refs.form && this.rqcForm[field]) {
        this.$refs.form.clearValidate([field]);
      }
    },

    // 物料编码输入后自动查询检测方案
    handleMaterialCodeBlur() {
      if (this.rqcForm.materialCode) {
        // 用户手动输入的情况，不使用静默模式
        this.$message.info(`正在根据物料编码【${this.rqcForm.materialCode}】查询对应的检测方案...`);
        this.findTemplateByMaterialCode(this.rqcForm.materialCode, false);
      }
    },

    // 表单提交
    submitForm() {
      console.log('【调试】开始提交表单');
      console.log('【调试】当前表单数据:', this.rqcForm);
      console.log('【调试】当前操作类型:', this.type);
      
      this.$refs["form"].validate(valid => {
        console.log('【调试】表单验证结果:', valid);
        if (valid) {
          console.log('【调试】表单验证通过，准备提交数据');
          
          // 设置加载状态
          this.submitting = true;
          // 额外验证数量关系
          const checkNum = Number(this.rqcForm.quantityCheckNum) || 0;
          const unqualifiedNum = Number(this.rqcForm.quantityUnqualifiedNum) || 0;
          const qualifiedNum = Number(this.rqcForm.quantityQualifiedNum) || 0;
          
          // 检验数量必须大于最小检测数
          if (this.templateParams.quantityCheckNum > 0 && checkNum < this.templateParams.quantityCheckNum) {
            this.$message.error(`检测数量(${checkNum})不能低于最小检测数量(${this.templateParams.quantityCheckNum})`);
            return;
          }
          
          // 不合格数和合格数不能大于检测数量
          if (unqualifiedNum > checkNum) {
            this.$message.error(`不合格数(${unqualifiedNum})不能大于检测数量(${checkNum})`);
            return;
          }
          
          if (qualifiedNum > checkNum) {
            this.$message.error(`合格数(${qualifiedNum})不能大于检测数量(${checkNum})`);
            return;
          }
          
          // 不合格数+合格数必须等于检测数量
          if (unqualifiedNum + qualifiedNum !== checkNum) {
            this.$message.error(`合格数(${qualifiedNum})与不合格数(${unqualifiedNum})之和必须等于检测数量(${checkNum})`);
            return;
          }
          
          // 如果不合格数超过最大不合格数但检测结果不是不合格，提示用户
          if (this.templateParams.quantityUnqualifiedNum > 0 && 
              unqualifiedNum > this.templateParams.quantityUnqualifiedNum && 
              this.rqcForm.checkResult !== '2') {
            this.$confirm(`不合格数(${unqualifiedNum})超过最大不合格数(${this.templateParams.quantityUnqualifiedNum})，检测结果应为不合格，是否自动调整？`, '提示', {
              confirmButtonText: '是',
              cancelButtonText: '否',
              type: 'warning'
            }).then(() => {
              this.rqcForm.checkResult = '2'; // 设置为不合格
              // 提交表单
              this.submitValidatedForm();
            }).catch(() => {
              this.$message.warning('请手动修正检测结果后重新提交');
              this.submitting = false; // 关闭提交加载状态
            });
          } else {
            // 所有验证通过，提交表单
            this.submitValidatedForm();
          }
        } else {
          // 验证失败时，关闭提交加载状态
          this.submitting = false;
        }
      });
    },
    
    // 验证通过后提交表单
    async submitValidatedForm() {
      // 显示全屏加载
      const loadingInstance = this.$loading({
        lock: true,
        text: this.type === 'add' ? '正在保存数据...' : '正在更新数据...',
        spinner: 'el-icon-loading',
        background: 'rgba(0, 0, 0, 0.7)'
      });
      
      // 创建表单数据的副本，避免修改原始数据
      const formData = JSON.parse(JSON.stringify(this.rqcForm));

      // 处理所有可能的日期字段 - 简化处理方式
      if (formData.inspectDate && typeof formData.inspectDate === 'string') {
        // 确保日期格式正确 - 使用日期选择器的value-format="yyyy-MM-dd"
        console.log('提交的日期格式:', formData.inspectDate);
      }
      
      // 如果是新增且开启系统编号，获取真正的消费编号
      if (this.type === 'add' && this.isSystemCode) {
        try {
          const response = await getAutoNumbersConsume(11);
          if (response && response.code === 200) {
            formData.rqcCode = response.msg;
            console.log('获取最终编号成功:', formData.rqcCode);
          } else {
            this.$message.error('获取最终编号失败，请重试');
            this.submitting = false;
            loadingInstance.close();
            return;
          }
        } catch (error) {
          console.error('获取最终编号失败:', error);
          this.$message.error('获取最终编号失败，请重试');
          this.submitting = false;
          loadingInstance.close();
          return;
        }
      }

      try {
        console.log('【调试】最终提交数据:', formData);
        
        // 提交表单数据
        this.$emit('submit', formData, () => {
          // 关闭加载状态（由父组件回调）
          this.submitting = false;
          if (loadingInstance) {
            loadingInstance.close();
          }
        });
        
        // 设置提交超时保护，避免加载状态卡住
        setTimeout(() => {
          // 如果1分钟后仍然在加载状态，自动关闭加载状态
          if (this.submitting) {
            console.warn('提交操作超时，自动关闭加载状态');
            this.submitting = false;
            if (loadingInstance) {
              loadingInstance.close();
            }
            this.$message.warning('操作响应超时，请刷新页面查看最新数据');
          }
        }, 60000);
      } catch (error) {
        // 发生错误时关闭加载状态
        console.error('提交表单时出错:', error);
        this.submitting = false;
        if (loadingInstance) {
          loadingInstance.close();
        }
      }
    },

    // 递归处理对象中所有日期格式字段
    formatDateFields(obj) {
      if (!obj || typeof obj !== 'object') return;

      Object.keys(obj).forEach(key => {
        const value = obj[key];

        // 如果是嵌套对象，递归处理
        if (value && typeof value === 'object' && !Array.isArray(value)) {
          this.formatDateFields(value);
        }
        // 如果是数组，遍历数组元素
        else if (Array.isArray(value)) {
          value.forEach(item => {
            if (item && typeof item === 'object') {
              this.formatDateFields(item);
            }
          });
        }
        // 处理日期字符串
        else if (typeof value === 'string') {
          // 检查是否类似日期字符串
          if (this.isDateString(value)) {
            // 格式化为yyyy-MM-dd格式
            obj[key] = this.formatDateString(value);
          }
        }
      });
    },

    // 判断字符串是否是日期格式
    isDateString(str) {
      // 匹配日期格式 yyyy-MM-dd 或 yyyy-MM-dd HH:mm:ss
      const datePattern = /^\d{4}-\d{2}-\d{2}(\s\d{2}:\d{2}:\d{2})?$/;
      return datePattern.test(str);
    },

    // 格式化日期字符串为yyyy-MM-dd格式
    formatDateString(dateStr) {
      if (!dateStr) return dateStr;

      try {
        // 如果包含空格（如"2025-07-17 00:00:00"），只保留日期部分
        if (dateStr.includes(' ')) {
          return dateStr.split(' ')[0];
        }
        // 如果包含T（如"2025-07-17T00:00:00"），只保留日期部分
        else if (dateStr.includes('T')) {
          return dateStr.split('T')[0];
        }
        return dateStr;
      } catch (e) {
        console.error('日期格式化错误:', e);
        return dateStr;
      }
    },

    // 更新退料单状态
    updateReturnIssueStatus(rtId, ipqcId, ipqcCode, ipqcName) {
      console.log('RqcForm接收到的更新参数:', {
        rtId, ipqcId, ipqcCode, ipqcName
      });

      // 参数检查，确保至少有rtId
      if (!rtId) {
        this.$message.error('退料单ID不能为空');
        return;
      }

      // 确保至少有ipqcId，如果没有则使用当前表单的ID
      const finalIpqcId = ipqcId || this.rqcForm.rqcId;
      const finalIpqcCode = ipqcCode || this.rqcForm.rqcCode;
      const finalIpqcName = ipqcName || this.rqcForm.rqcName;

      console.log('最终使用的更新参数:', {
        rtId,
        ipqcId: finalIpqcId,
        ipqcCode: finalIpqcCode,
        ipqcName: finalIpqcName
      });

      updateCkRtIssueStatus(rtId, finalIpqcId, finalIpqcCode, finalIpqcName).then(response => {
        if (response.code === 200) {
          this.$message.success('退料单状态已更新');
          console.log('退料单状态更新成功:', response);
        } else {
          this.$message.error('退料单状态更新失败');
          console.error('退料单状态更新失败:', response);
        }
      }).catch(error => {
        console.error('更新退料单状态异常', error);
        this.$message.error('更新退料单状态异常：' + (error.message || '未知错误'));
      });
    },

    // 取消按钮
    cancel() {
      this.$emit('cancel');
    },

    // 打开退料单选择器
    openReturnIssueSelector() {
      if (this.isView) return;
      this.returnIssueDialogVisible = true;
      this.loadReturnIssueList();
    },

    // 处理退料单搜索
    handleReturnIssueSearch() {
      this.returnIssuePageNum = 1;
      this.loadReturnIssueList();
    },
    
    // 重置退料单搜索
    resetReturnIssueSearch() {
      this.returnIssueQueryParams = {
        recpt_code: '',
        recpt_name: ''
      };
      this.returnIssuePageNum = 1;
      this.loadReturnIssueList();
    },

    // 加载退料单列表
    loadReturnIssueList() {
      this.returnIssueLoading = true;
      
      // 创建一个包含分页和查询参数的对象
      const params = {
        pageNum: this.returnIssuePageNum,
        pageSize: this.returnIssuePageSize,
        recpt_code: this.returnIssueQueryParams.recpt_code,
        recpt_name: this.returnIssueQueryParams.recpt_name,
        status: 2
      };
      
      console.log('发送查询参数:', params);
      
      selectCkProductRecptDetectSingle(params).then(response => {
        console.log('来源单据列表原始响应:', response);
        
        // 清空当前列表
        this.returnIssueList = [];
        
        // 根据实际返回结构处理数据
        if (response) {
          let responseData = null;
          
          // 处理不同的返回结构情况
          if (response.code === 200) {
            if (response.rows) {
              // 返回标准分页格式 {code: 200, rows: [...], total: 100}
              responseData = response.rows;
              this.returnIssueTotal = response.total || 0;
            } else if (response.data) {
              // 返回格式 {code: 200, data: [...]}
              responseData = response.data;
              this.returnIssueTotal = responseData.length || 0;
            }
          } else if (Array.isArray(response)) {
            // 直接返回数组格式
            responseData = response;
            this.returnIssueTotal = responseData.length || 0;
          } else if (typeof response === 'object' && !response.code) {
            // 可能是一个包含数据但没有code字段的对象
            responseData = [response];
            this.returnIssueTotal = 1;
          }
          
          // 如果找到了数据，进行映射处理
          if (responseData && Array.isArray(responseData)) {
            console.log('处理前的数据:', responseData);
            
            this.returnIssueList = responseData.map(item => {
              // 创建一个统一格式的对象
              return {
                ...item,
                recpt_id: item.recpt_id || item.rt_id,
                recpt_code: item.recpt_code || item.rt_code,
                recpt_date: item.recpt_date || item.rt_date,
                material_id: item.material_id,
                goods_code: item.goods_code,
                goods_name: item.goods_name,
                stock_sfn: item.stock_sfn,
                unit_name: item.unit_name || item.unit
              };
            });
            
            console.log('映射后的退料单列表:', this.returnIssueList);
          } else {
            console.error('无法识别的数据结构:', response);
            this.$message.warning('获取退料单列表失败: 无法识别的数据结构');
          }
        } else {
          console.error('获取退料单列表失败: 响应为空');
          this.$message.error('获取退料单列表失败: 服务器无响应');
        }
      }).catch(error => {
        console.error('获取退料单列表异常', error);
        this.$message.error('获取退料单列表异常：' + (error.message || '未知错误'));
      }).finally(() => {
        this.returnIssueLoading = false;
      });
    },

    // 处理退料单行点击
    handleReturnIssueRowClick(row) {
      this.selectedReturnIssue = row;
    },

    // 确认选择退料单
    confirmReturnIssue() {
      if (!this.selectedReturnIssue) {
        this.$message.warning('请选择一个退料单');
        return;
      }

      // 设置表单中的退料单相关信息
      this.rqcForm.sourceDocId = this.selectedReturnIssue.recpt_id;
      this.rqcForm.sourceDocCode = this.selectedReturnIssue.recpt_code;

      // 同时回显物料信息
      this.rqcForm.materialId = this.selectedReturnIssue.material_id;
      this.rqcForm.materialCode = this.selectedReturnIssue.goods_code;
      this.rqcForm.materialName = this.selectedReturnIssue.goods_name;
      this.rqcForm.materialSfn = this.selectedReturnIssue.stock_sfn;
      this.rqcForm.unit = this.selectedReturnIssue.unit_name;
      this.rqcForm.unitName = this.selectedReturnIssue.unit_name;
      
      // 设置检测数量
      if (this.selectedReturnIssue.quantity) {
        this.rqcForm.quantityCheckNum = Number(this.selectedReturnIssue.quantity);
      }
      
      // 自动生成检验单名称
      if (!this.rqcForm.rqcName) {
        this.rqcForm.rqcName = `${this.rqcForm.materialName}退料检验单`;
      }

      // 清除相关字段的验证提示
      if (this.$refs.form) {
        this.$refs.form.clearValidate(['sourceDocId']);
        this.$refs.form.clearValidate(['sourceDocCode']);
        this.$refs.form.clearValidate(['materialId']);
        this.$refs.form.clearValidate(['materialCode']);
        this.$refs.form.clearValidate(['materialName']);
        this.$refs.form.clearValidate(['materialSfn']);
        this.$refs.form.clearValidate(['unit']);
      }

      // 根据物料编码查询检测方案ID
      if (this.rqcForm.materialCode) {
        // 用户主动选择退料单，不使用静默模式
        this.$message.info(`已选择物料编码【${this.rqcForm.materialCode}】，正在查询对应的检测方案...`);
        this.findTemplateByMaterialCode(this.rqcForm.materialCode, false);
      }

      this.$message.success('退料单选择成功');
      this.returnIssueDialogVisible = false;
    },
    
    // 根据物料编码查询对应的质检方案ID
    findTemplateByMaterialCode(materialCode, silent = false) {
      if (!materialCode) {
        console.warn('【查询检测方案】物料编码为空，无法查询');
        if (!silent) {
          this.$message.warning('物料编码为空，无法查询对应的检测方案');
        }
        return;
      }
      
      // 记录当前表单中的模板ID，用于后续比较
      const currentTemplateId = this.rqcForm.templateId;
      
      console.log('【查询检测方案】开始通过物料编码查询，物料编码：', materialCode, '当前模板ID:', currentTemplateId);
      
      const loadingInstance = this.$loading({
        lock: true,
        text: '正在查询对应的检测方案...',
        spinner: 'el-icon-loading',
        background: 'rgba(0, 0, 0, 0.7)'
      });
      
      // 使用selectQcTemplateProductMaterialCode方法查询
      selectQcTemplateProductMaterialCode(materialCode).then(response => {
        loadingInstance.close();
        
        console.log('【通过物料编码查询】获取到的完整响应：', response);
        let templateId = null;
        let templateData = null;
        
        // 处理不同的返回格式情况
        if (response && typeof response === 'object') {
          if (response.template_id) {
            // 如果返回的是包含template_id字段的对象
            templateId = response.template_id;
            templateData = response;
          } else if (response.data && response.data.template_id) {
            // 如果是标准响应格式，从data中取值
            templateId = response.data.template_id;
            templateData = response.data;
          } else if (response.rows && response.rows.length > 0) {
            // 如果返回的是结果集
            templateId = response.rows[0].template_id;
            templateData = response.rows[0];
          }
        } else if (typeof response === 'number') {
          // 如果直接返回的就是数字
          templateId = response;
        } else if (typeof response === 'string' && !isNaN(Number(response))) {
          // 如果返回的是字符串形式的数字
          templateId = response;
        }
        
        // 转换为数字便于比较
        const numericTemplateId = templateId ? Number(templateId) : null;
        const numericCurrentTemplateId = currentTemplateId ? Number(currentTemplateId) : null;
        
        if (numericTemplateId) {
          this.$message.success('成功查询到检测方案');
          console.log('【通过物料编码查询】提取的检测方案ID：', numericTemplateId, '当前ID:', numericCurrentTemplateId);
          
          // 检查是否与当前ID相同
          if (numericTemplateId === numericCurrentTemplateId) {
            console.log('【通过物料编码查询】检测方案ID未变化，仍需更新显示');
            
            // 即使ID相同也需要更新显示
            this.rqcForm.templateId = numericTemplateId;
            
            // 处理模板数据并回显
            if (templateData) {
              this.processTemplateResponse(templateData, silent);
            }
            
          } else {
            // ID不同时，显示提示并更新
            this.setTemplateInfo(numericTemplateId, silent);
            
            // 如果有模板数据，直接处理
            if (templateData) {
              this.processTemplateResponse(templateData, silent);
            } else {
              // 没有模板数据，使用ID获取模板参数
              this.getTemplateParams(numericTemplateId, silent);
            }
          }
        } else {
          console.warn('【通过物料编码查询】未找到检测方案，物料编码:', materialCode);
          this.$message.warning(`未找到物料编码【${materialCode}】对应的检测方案，请手动选择`);
        }
      }).catch(error => {
        loadingInstance.close();
        console.error('通过物料编码查询检测方案异常', error);
        this.$message.error('查询检测方案异常：' + (error.message || '未知错误'));
      });
    },
    
    
    // 设置模板信息到表单
    setTemplateInfo(templateId, silent = false) {
      if (!templateId) return;
      
      console.log('【开始设置模板信息】检测方案ID原始值：', templateId, '类型:', typeof templateId);
      
      let numericTemplateId;
      
      // 处理不同的数据类型情况
      if (typeof templateId === 'number') {
        numericTemplateId = templateId;
      } else if (typeof templateId === 'string' && !isNaN(Number(templateId))) {
        numericTemplateId = Number(templateId);
      } else if (typeof templateId === 'object' && templateId !== null) {
        // 如果是对象，尝试提取template_id
        if (templateId.template_id !== undefined) {
          numericTemplateId = Number(templateId.template_id);
        } else if (templateId.id !== undefined) {
          numericTemplateId = Number(templateId.id);
        } else {
          // 尝试将对象转为数字（针对特殊情况）
          const strValue = String(templateId).trim();
          if (!isNaN(Number(strValue))) {
            numericTemplateId = Number(strValue);
          } else {
            console.error('无法从对象中提取有效的模板ID:', templateId);
            this.$message.warning('检测方案ID格式异常，请重新选择');
            return;
          }
        }
      } else {
        console.error('检测方案ID格式无法识别:', templateId);
        this.$message.warning('检测方案ID格式不正确，请重新选择');
        return;
      }
      
      // 最后验证转换结果
      if (isNaN(numericTemplateId)) {
        console.error('检测方案ID数值转换失败:', templateId, '转换结果:', numericTemplateId);
        this.$message.warning('检测方案ID格式不正确，请重新选择');
        return;
      }
      
      console.log('【模板信息】成功转换为数字:', numericTemplateId);
      
      // 先设置ID，确保即使后续API调用失败，ID也已设置到表单中
      this.rqcForm.templateId = numericTemplateId;
      
      // 清除templateId字段的验证提示
      if (this.$refs.form) {
        this.$refs.form.clearValidate(['templateId']);
      }
      
      // 获取检测方案详细参数
      this.getTemplateParams(numericTemplateId, silent);
      
    },
    
    // 获取检测方案详细参数
    getTemplateParams(templateId, silent = false) {
      if (!templateId) return;
      
      // 确保templateId是数字
      let numericTemplateId;
      try {
        numericTemplateId = Number(templateId);
        if (isNaN(numericTemplateId)) {
          console.error('无法将模板ID转换为数字:', templateId);
          this.$message.warning('检测方案ID格式异常，请重新选择');
          return;
        }
      } catch (e) {
        console.error('templateId转换异常:', e);
        this.$message.warning('检测方案ID处理异常，请重新选择');
        return;
      }
      
      // 只在非静默模式下显示加载状态
      let loading = null;
      if (!silent && !this.isInitializing) {
        loading = this.$loading({
        lock: true,
        text: '正在加载检测方案参数...',
        spinner: 'el-icon-loading',
        background: 'rgba(0, 0, 0, 0.7)'
      });
      }
      
      console.log('【检测方案参数】准备请求参数，模板ID:', numericTemplateId);
      
      // 使用物料编码查询模板信息
      if (this.rqcForm.materialCode) {
        selectQcTemplateProductMaterialCode(this.rqcForm.materialCode).then(res => {
          if (loading) loading.close();
          this.processTemplateResponse(res, silent);
        }).catch(err => {
          if (loading) loading.close();
          console.error('【检测方案参数】通过物料编码请求异常:', err);
          if (!silent && !this.isInitializing) {
          this.$message.error('获取检测方案参数异常: ' + (err.message || '未知错误'));
          }
        });
      } else {
        if (loading) loading.close();
        if (!silent && !this.isInitializing) {
        this.$message.warning('没有物料编码，无法获取检测方案参数');
        }
      }
    },
    
    // 获取模板显示文本，格式为 "ID: 名称"
    getTemplateDisplay() {
      if (this.rqcForm.templateId) {
        if (this.rqcForm.templateName) {
          return `ID: ${this.rqcForm.templateId} - ${this.rqcForm.templateName}`;
        } else {
          return `ID: ${this.rqcForm.templateId}`;
        }
      } else if (this.rqcForm.templateName) {
        return this.rqcForm.templateName;
      }
      return '';
    },
    
    // 处理模板响应数据
    processTemplateResponse(response, silent = false) {
      console.log('【检测方案参数】API返回原始数据:', response);
      
      let templateData = null;
      
      // 处理不同的响应格式
      if (response && typeof response === 'object') {
        if (response.data && response.code === 200) {
          // 标准响应格式
          templateData = response.data;
        } else if (response.template_id) {
          // 直接返回模板对象
          templateData = response;
        } else if (response.code === 200 && response.rows && response.rows.length > 0) {
          // 返回结果集
          templateData = response.rows[0];
        }
      }
      
      if (templateData) {
        // 记录原有参数
        const oldParams = { ...this.templateParams };
        
        // 设置检测参数
        this.templateParams = {
          quantityCheckNum: templateData.quantity_check_num != null ? Number(templateData.quantity_check_num) : 0,
          quantityUnqualifiedNum: templateData.quantity_unqualified_num != null ? Number(templateData.quantity_unqualified_num) : 0,
          crRate: templateData.cr_rate != null ? Number(templateData.cr_rate) : 0,
          majRate: templateData.maj_rate != null ? Number(templateData.maj_rate) : 0,
          minRate: templateData.min_rate != null ? Number(templateData.min_rate) : 0
        };
        
        // 总是设置模板ID到表单中，确保回显
        if (templateData.template_id) {
          this.rqcForm.templateId = templateData.template_id;
          
          // 如果有模板名称，也设置
          if (templateData.template_name) {
            this.rqcForm.templateName = templateData.template_name;
          }
          
          // 强制更新视图
          this.$forceUpdate();
        }
        
        // 检查参数是否有变化
        const paramsChanged = JSON.stringify(oldParams) !== JSON.stringify(this.templateParams);
        
        // 同时设置模板名称和编码
        if (templateData.template_name) {
          this.rqcForm.templateName = templateData.template_name;
        }
        if (templateData.template_code) {
          this.rqcForm.templateCode = templateData.template_code;
        }
        
        // 如果检测数量为0，则回显最低检测数量
        if (this.rqcForm.quantityCheckNum === 0 && this.templateParams.quantityCheckNum > 0) {
          this.rqcForm.quantityCheckNum = this.templateParams.quantityCheckNum;
        }
        
        console.log('【检测方案参数】获取成功，处理后参数:', this.templateParams);
        
        // 只有在非静默模式且参数有变化时才显示提示
        if (!silent && !this.isInitializing && paramsChanged) {
          this.$message.success(`已获取检测方案(${this.rqcForm.templateName || this.rqcForm.templateId})参数设置`);
        }
        
        // 更新验证规则
        this.setupValidationRules();
      } else {
        console.warn('【检测方案参数】获取失败，响应异常:', response);
      }
    },
    
    // 设置验证规则
    setupValidationRules() {
      // 检测数量验证
      const checkQuantityRule = (rule, value, callback) => {
        if (value < this.templateParams.quantityCheckNum) {
          callback(new Error(`检测数量不能低于${this.templateParams.quantityCheckNum}`));
        } else {
          callback();
        }
      };
      
      // 不合格数验证
      const checkUnqualifiedRule = (rule, value, callback) => {
        const checkNum = Number(this.rqcForm.quantityCheckNum) || 0;
        
        if (value > checkNum) {
          callback(new Error(`不合格数不能大于检测数量${checkNum}`));
        } else if (value > this.templateParams.quantityUnqualifiedNum) {
          this.$confirm(`不合格数(${value})已超过最大不合格数(${this.templateParams.quantityUnqualifiedNum})，是否自动设置为不合格？`, '提示', {
            confirmButtonText: '是',
            cancelButtonText: '否',
            type: 'warning'
          }).then(() => {
            this.rqcForm.checkResult = '2'; // 设置为不合格
            callback();
          }).catch(() => {
            callback();
          });
        } else {
          callback();
        }
      };
      
      // 合格数验证
      const checkQualifiedRule = (rule, value, callback) => {
        const checkNum = Number(this.rqcForm.quantityCheckNum) || 0;
        const unqualifiedNum = Number(this.rqcForm.quantityUnqualifiedNum) || 0;
        
        if (value > checkNum) {
          callback(new Error(`合格数不能大于检测数量${checkNum}`));
        } else if (value + unqualifiedNum !== checkNum) {
          callback(new Error(`合格数与不合格数之和(${value + unqualifiedNum})必须等于检测数量(${checkNum})`));
        } else {
          callback();
        }
      };
      
      // 更新规则
      this.rules.quantityCheckNum = [
        { required: true, message: "检测数量不能为空", trigger: "blur" },
        { validator: checkQuantityRule, trigger: "blur" }
      ];
      
      this.rules.quantityUnqualifiedNum = [
        { required: true, message: "不合格数不能为空", trigger: "blur" },
        { validator: checkUnqualifiedRule, trigger: "blur" }
      ];
      
      this.rules.quantityQualifiedNum = [
        { required: true, message: "合格品数量不能为空", trigger: "blur" },
        { validator: checkQualifiedRule, trigger: "blur" }
      ];
      
      // 如果表单已经存在，重新应用验证规则
      if (this.$refs.form) {
        this.$nextTick(() => {
          this.$refs.form.clearValidate();
        });
      }
    },
    
    // 监听数量变化，自动判断检测结果
    watchQuantities() {
      // 检测缺陷率并判断结果
      const checkNum = Number(this.rqcForm.quantityCheckNum) || 0;
      if (checkNum <= 0) return;
      
      const crNum = Number(this.rqcForm.crQuantityNum) || 0;
      const majNum = Number(this.rqcForm.majQuantityNum) || 0;
      const minNum = Number(this.rqcForm.minQuantityNum) || 0;
      const unqualifiedNum = Number(this.rqcForm.quantityUnqualifiedNum) || 0;
      const qualifiedNum = Number(this.rqcForm.quantityQualifiedNum) || 0;
      
      // 检查检测数量是否满足最低要求
      if (this.templateParams.quantityCheckNum > 0 && checkNum < this.templateParams.quantityCheckNum) {
        this.$message.warning(`检测数量(${checkNum})不满足最小检测数量要求(${this.templateParams.quantityCheckNum})`);
      }
      
      // 验证不合格数+合格数是否等于检测数量
      if (unqualifiedNum + qualifiedNum !== checkNum) {
        console.warn(`数量不平衡：不合格数(${unqualifiedNum})+合格数(${qualifiedNum})≠检测数量(${checkNum})`);
      }
      
      // 计算实际缺陷率
      const crRate = crNum / checkNum * 100;
      const majRate = majNum / checkNum * 100;
      const minRate = minNum / checkNum * 100;
      
      // 检查是否超过阈值
      let isQualified = true;
      let warningMsg = '';
      
      if (unqualifiedNum > this.templateParams.quantityUnqualifiedNum) {
        isQualified = false;
        warningMsg = `不合格数(${unqualifiedNum})已超过最大限制(${this.templateParams.quantityUnqualifiedNum})`;
      } else if (crRate > this.templateParams.crRate) {
        isQualified = false;
        warningMsg = `致命缺陷率(${crRate.toFixed(2)}%)已超过限制(${this.templateParams.crRate}%)`;
      } else if (majRate > this.templateParams.majRate) {
        isQualified = false;
        warningMsg = `严重缺陷率(${majRate.toFixed(2)}%)已超过限制(${this.templateParams.majRate}%)`;
      } else if (minRate > this.templateParams.minRate) {
        isQualified = false;
        warningMsg = `轻微缺陷率(${minRate.toFixed(2)}%)已超过限制(${this.templateParams.minRate}%)`;
      }
      
      // 自动设置检测结果
      if (!isQualified) {
        // 静默设置为不合格，不再弹窗询问
        if (this.rqcForm.checkResult !== '2') {
          console.log(`${warningMsg}，自动设置为不合格`);
          this.rqcForm.checkResult = '2'; // 设置为不合格
        }
      } else if (unqualifiedNum === 0 && checkNum > 0 && this.rqcForm.checkResult === '3') {
        // 如果没有不合格品且检测数大于0，自动设置为合格
        this.rqcForm.checkResult = '1';
      }
    },
    
    // 检查所有数据限制
    validateAllLimits() {
      // 检测数量
      const checkNum = Number(this.rqcForm.quantityCheckNum) || 0;
      const unqualifiedNum = Number(this.rqcForm.quantityUnqualifiedNum) || 0;
      const qualifiedNum = Number(this.rqcForm.quantityQualifiedNum) || 0;
      
      const errors = [];
      
      // 1. 检测数量必须大于最小检测数
      if (this.templateParams.quantityCheckNum > 0 && checkNum < this.templateParams.quantityCheckNum) {
        errors.push(`检测数量(${checkNum})不能低于最小检测数量(${this.templateParams.quantityCheckNum})`);
      }
      
      // 2. 不合格数不能大于检测数量
      if (unqualifiedNum > checkNum) {
        errors.push(`不合格数(${unqualifiedNum})不能大于检测数量(${checkNum})`);
      }
      
      // 3. 合格数不能大于检测数量
      if (qualifiedNum > checkNum) {
        errors.push(`合格数(${qualifiedNum})不能大于检测数量(${checkNum})`);
      }
      
      // 4. 不合格数+合格数必须等于检测数量
      if (unqualifiedNum + qualifiedNum !== checkNum) {
        errors.push(`合格数(${qualifiedNum})与不合格数(${unqualifiedNum})之和必须等于检测数量(${checkNum})`);
      }
      
      return errors;
    }
  }
};
</script>

<style scoped>
.rqc-form {
  display: flex;
  flex-direction: column;
  height: 580px;
  width: 100%;
  min-height: 580px;
  max-height: 580px;
}

.form-tabs {
  margin-bottom: 15px;
  background: #fff;
  padding: 10px 20px 0;
  border-radius: 4px;
  box-shadow: 0 2px 4px rgba(0, 0, 0, 0.1);
}

.form-content-area {
  flex: 1;
  overflow-y: auto;
  min-height: 450px;
  max-height: 450px;
  padding-right: 5px;
}

.form-card {
  margin-bottom: 15px;
}

.card-header {
  display: flex;
  justify-content: space-between;
  align-items: center;
}

.card-header span {
  font-weight: bold;
  color: #409EFF;
}

.form-container {
  padding: 20px 0;
}

.form-footer {
  height: 50px;
  text-align: center;
  background: #fff;
  padding: 8px 0;
  box-shadow: 0 -2px 8px rgba(0, 0, 0, 0.1);
  margin-top: 10px;
  flex-shrink: 0;
  border-radius: 4px;
}

/* 确保输入框宽度一致 */
.el-input {
  width: 100%;
}

/* 输入框内容显示优化 */
::v-deep .el-input__inner {
  padding-right: 15px;
  text-overflow: ellipsis;
  font-size: 14px;
}

/* 按钮内嵌输入框样式 */
.input-with-btn {
  position: relative;
  width: 100%;
}

/* 按钮与输入框组合的样式 */
::v-deep .el-input-group__append {
  padding: 0;
  background-color: transparent;
  border: none;
}

::v-deep .inner-button {
  height: 32px;
  padding: 7px 15px;
  border-radius: 0 4px 4px 0;
  margin-left: 0;
  border-left: 1px solid #dcdfe6;
}

/* 确保下拉菜单宽度足够显示内容 */
::v-deep .el-select-dropdown {
  min-width: 250px !important;
}

/* 优化placeholder文字 */
::v-deep .el-input__inner::placeholder {
  font-size: 14px;
}

/* 调整表单项之间的间距 */
.el-form-item {
  margin-bottom: 22px;
}

/* 标签宽度优化 */
::v-deep .el-form-item__label {
  width: 120px !important;
  padding-right: 12px;
  font-size: 14px;
  overflow: hidden;
  text-overflow: ellipsis;
  white-space: nowrap;
  text-align: right;
}

/* 整体字体大小略微缩小，增加内容密度 */
.rqc-form {
  font-size: 0.95em;
}

/* 调整行间距以适应更多内容 */
.el-row {
  margin-bottom: 10px;
}

/* 数字输入框样式调整 */
.el-input-number.el-input-number--medium {
  width: 100%;
}

::v-deep .el-input-number__decrease,
::v-deep .el-input-number__increase {
  background-color: #f5f7fa;
}

/* 按钮文字显示优化 */
::v-deep .inner-button span {
  font-size: 14px;
}

/* 禁用输入框样式 */
.disabled-input {
  background-color: #f5f7fa !important;
  color: #606266 !important;
  border: 1px dashed #d9d9d9 !important;
  cursor: not-allowed !important;
}

/* 标签页样式增强 */
::v-deep .el-tabs__item {
  height: 40px;
  line-height: 40px;
  font-size: 14px;
  font-weight: 500;
  transition: all 0.3s;
  padding: 0 20px;
}

::v-deep .el-tabs__item:hover {
  color: #409EFF;
}

::v-deep .el-tabs__item.is-active {
  color: #409EFF;
  font-weight: bold;
}

/* 自定义滚动条样式 */
.form-content-area::-webkit-scrollbar {
  width: 8px;
  height: 8px;
}

.form-content-area::-webkit-scrollbar-thumb {
  background: #c1c1c1;
  border-radius: 4px;
}

.form-content-area::-webkit-scrollbar-track {
  background: #f1f1f1;
  border-radius: 4px;
}

/* 表单提示样式 */
.form-tip {
  font-size: 12px;
  color: #909399;
  line-height: 1.2;
  margin-top: 4px;
}

/* 响应式样式调整 */
@media screen and (max-width: 1400px) {
  .rqc-form {
    padding: 5px;
  }

  .el-row {
    margin-left: -10px !important;
    margin-right: -10px !important;
  }

  .el-col {
    padding-left: 10px !important;
    padding-right: 10px !important;
  }
}
</style>
